|
In computer programming, a constant is an identifier with an associated value which cannot be altered by the program during normal execution – the value is ''constant''. This is contrasted with a ''variable,'' which is an identifier with a value that can be changed during normal execution – the value is ''variable.'' Constants are useful for both programmers and compilers: for programmers they are a form of self-documenting code and allow reasoning about correctness; while for compilers they allow compile-time and run-time checks that constancy assumptions are not violated, and allow or simplify some compiler optimizations. There are various specific realizations of the general notion of a constant, with subtle distinctions that are often overlooked. The most significant are: compile-time (statically-valued) constants, run-time (dynamically-valued) constants, immutable objects, and constant types (const). Typical examples of compile-time constants include mathematical constants, values from standards (here maximum transmission unit), or internal configuration values (here characters per line), such as these C examples: const float PI = 3.1415927; // maximal single float precision const unsigned int MTU = 1500; // Ethernet v2, RFC 894 const unsigned int COLUMNS = 80; Typical examples of run-time constants are values calculated based on inputs to a function, such as this C++ example: void f(std::string s) ==Use== Some programming languages make an explicit syntactic distinction between constant and variable symbols, for example considering assignment to a constant to be a syntax error, while in other languages they are considered syntactically the same (both simply an identifier), and the difference in treatment is semantic (assignment to an identifier is syntactically valid, but if the identifier is a constant it is semantically invalid). Although a constant's value is defined only once, a constant may be referenced many times in a program. Using a constant instead of specifying a value multiple times in the program does not only simplify code maintenance (as in don't repeat yourself), but it can also supply a meaningful name for it and can consolidate such constant bindings to a standard code location (for example, at the beginning or in a separate file). ==Comparison with literals and macros== There are several main ways to express a data value that doesn't change during program execution that are consistent across a wide variety of programming languages. One very basic way is by simply writing a literal number, character, or string into the program code, which is straightforward in C, C++, and similar languages. In assembly language, literal numbers and characters are done using the "immediate mode" instructions available on most microprocessors. The name "immediate" comes from the values being available immediately from the instruction stream, as opposed to loading them indirectly by looking up a memory address.〔Ex. (IBM Systems Information ). Instruction Set - Assembler Language Reference for PowerPC.〕 On the other hand, values longer than the microprocessor's word length, such as strings and arrays, are handled indirectly and assemblers generally provide a "data" pseudo-op to embed such data tables in a program. Another way is by defining a symbolic macro. Many high-level programming languages, and many assemblers, offer a macro facility where the programmer can define, generally at the beginning of a source file or in a separate definition file, names for different values. A preprocessor then replaces these names with the appropriate values before compiling, resulting in something functionally identical to using literals, with the speed advantages of immediate mode. Because it can be difficult to maintain code where all values are written literally, if a value is used in any repetitive or non-obvious way, it is often done as a macro. A third way is by declaring and defining a variable as being "constant". A global or static variable can be declared (or a symbol defined in assembly) with a keyword qualifier such as , constant, or meaning that its value will be set at compile time and should not be changeable at runtime. Compilers generally put static constants in the text section of an object file along with the code itself, as opposed to the data section where non-const initialized data is kept, though some have an option to produce a section specifically dedicated to constants, if so desired. Memory protection can be applied to this area to prevent overwriting of constant variables by errant pointers.These "constant variables" differ from literals in a number of ways. Compilers generally place a constant in a single memory location identified by symbol, rather than spread throughout the executable as with a macro. While this precludes the speed advantages of immediate mode, there are advantages in memory efficiency, and debuggers can work with these constants at runtime. Also while macros may be redefined accidentally by conflicting header files in C and C++, conflicting constants are detected at compile time. Depending upon the language, constants can be untyped or typed. In C and C++, macros provide the former, while provides the latter: #define PI 3.1415926535 const float pi2 = 3.1415926535; while in Ada, there are universal numeric types that can be used, if desired: pi : constant := 3.1415926535; pi2 : constant float := 3.1415926535; with the untyped variant being implicitly converted to the appropriate type upon each use. 抄文引用元・出典: フリー百科事典『 ウィキペディア（Wikipedia）』 ■ウィキペディアで「Constant (computer programming)」の詳細全文を読む スポンサード リンク
|